home *** CD-ROM | disk | FTP | other *** search
/ The Utilities Experience / The Utilities Experience - Volume 1.iso / software / misc / o-z / x-windows / mesa-amiwin / src / depth.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-30  |  15.6 KB  |  782 lines
  1. /* depth.c */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  1.2
  6.  * Copyright (C) 1995  Brian Paul  (brianp@ssec.wisc.edu)
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25. $Id: depth.c,v 1.13 1995/11/30 00:18:54 brianp Exp $
  26.  
  27. $Log: depth.c,v $
  28.  * Revision 1.13  1995/11/30  00:18:54  brianp
  29.  * manually unrolled loop in gl_clear_depth_buffer()
  30.  *
  31.  * Revision 1.12  1995/09/22  21:53:35  brianp
  32.  * optimized gl_clear_depth_buffer for loop unrolling
  33.  *
  34.  * Revision 1.11  1995/07/11  15:10:38  brianp
  35.  * fixed bug in gl_depth_test_span when func=GL_ALWAYS and DepthMask=GL_FALSE
  36.  *
  37.  * Revision 1.10  1995/06/21  15:09:17  brianp
  38.  * added a comment to gl_clear_depth_buffer
  39.  *
  40.  * Revision 1.9  1995/06/15  21:08:05  brianp
  41.  * fixed bug in gl_read_depth_span() per Asif Khan
  42.  *
  43.  * Revision 1.8  1995/06/09  20:20:50  brianp
  44.  * renamed gl_depth_test() as gl_depth_test_span() and return 'passed' count
  45.  *
  46.  * Revision 1.7  1995/05/22  21:02:41  brianp
  47.  * Release 1.2
  48.  *
  49.  * Revision 1.6  1995/05/12  19:24:13  brianp
  50.  * replaced CC.Mode!=0 with INSIDE_BEGIN_END
  51.  *
  52.  * Revision 1.5  1995/04/19  13:48:18  brianp
  53.  * renamed occurances of near and far for SCO x86 Unix
  54.  *
  55.  * Revision 1.4  1995/03/09  21:34:01  brianp
  56.  * removed #include stdio.h
  57.  *
  58.  * Revision 1.3  1995/03/04  19:29:44  brianp
  59.  * 1.1 beta revision
  60.  *
  61.  * Revision 1.2  1995/02/27  22:48:39  brianp
  62.  * modified for PB
  63.  *
  64.  * Revision 1.1  1995/02/24  14:20:28  brianp
  65.  * Initial revision
  66.  *
  67.  */
  68.  
  69.  
  70. /*
  71.  * Depth buffer functions
  72.  */
  73.  
  74.  
  75.  
  76. /* NOTES:
  77.  
  78. The depth buffer is implemented with GLint's (4-byte signed integers).
  79. Window depth coordinates are considered to be floats in [0,1].  We convert
  80. these values to integers by multiplying by MAX_DEPTH.  Note that we
  81. aren't using the full range of integer values on purpose.  Since a Bres-
  82. enham style algorithm is used to interpolate integer Z values, we have
  83. to be careful to avoid integer overflow.
  84.  
  85. */
  86.  
  87.  
  88.  
  89. #include <stdlib.h>
  90. #include <string.h>
  91. #include "context.h"
  92. #include "list.h"
  93. #include "macros.h"
  94.  
  95.  
  96.  
  97.  
  98. void glClearDepth( GLclampd depth )
  99. {
  100.    if (CC.CompileFlag) {
  101.       gl_save_cleardepth( (GLfloat) depth );
  102.    }
  103.    if (CC.ExecuteFlag) {
  104.       if (INSIDE_BEGIN_END) {
  105.      gl_error( GL_INVALID_OPERATION, "glClearDepth" );
  106.       }
  107.       CC.Depth.Clear = (GLfloat) CLAMP( depth, 0.0, 1.0 );
  108.    }
  109. }
  110.  
  111.  
  112.  
  113. void glDepthFunc( GLenum func )
  114. {
  115.    if (CC.CompileFlag) {
  116.       gl_save_depthfunc( func );
  117.    }
  118.  
  119.    if (CC.ExecuteFlag) {
  120.       if (INSIDE_BEGIN_END) {
  121.      gl_error( GL_INVALID_OPERATION, "glDepthFunc" );
  122.       }
  123.  
  124.       switch (func) {
  125.      case GL_NEVER:
  126.      case GL_LESS:    /* (default) pass if incoming z < stored z */
  127.      case GL_GEQUAL:
  128.      case GL_LEQUAL:
  129.      case GL_GREATER:
  130.      case GL_NOTEQUAL:
  131.      case GL_EQUAL:
  132.      case GL_ALWAYS:
  133.         CC.Depth.Func = func;
  134.         break;
  135.      default:
  136.         gl_error( GL_INVALID_ENUM, "glDepth.Func" );
  137.       }
  138.    }
  139. }
  140.  
  141.  
  142.  
  143. void glDepthMask( GLboolean flag )
  144. {
  145.    if (CC.CompileFlag) {
  146.       gl_save_depthmask( flag );
  147.    }
  148.    if (CC.ExecuteFlag) {
  149.       if (INSIDE_BEGIN_END) {
  150.      gl_error( GL_INVALID_OPERATION, "glDepthMask" );
  151.       }
  152.  
  153.       /*
  154.        * GL_TRUE indicates depth buffer writing is enabled (default)
  155.        * GL_FALSE indicates depth buffer writing is disabled
  156.        */
  157.       CC.Depth.Mask = flag;
  158.    }
  159. }
  160.  
  161.  
  162.  
  163. void glDepthRange( GLclampd nearval, GLclampd farval )
  164. {
  165.    /*
  166.     * nearval - specifies mapping of the near clipping plane to window
  167.     *   coordinates, default is 0
  168.     * farval - specifies mapping of the far clipping plane to window
  169.     *   coordinates, default is 1
  170.     *
  171.     * After clipping and div by w, z coords are in -1.0 to 1.0,
  172.     * corresponding to near and far clipping planes.  glDepthRange
  173.     * specifies a linear mapping of the normalized z coords in
  174.     * this range to window z coords.
  175.     */
  176.  
  177.    if (CC.CompileFlag) {
  178.       gl_save_depthrange( nearval, farval );
  179.    }
  180.    if (CC.ExecuteFlag) {
  181.       GLfloat n, f;
  182.  
  183.       if (INSIDE_BEGIN_END) {
  184.      gl_error( GL_INVALID_OPERATION, "glDepthRange" );
  185.       }
  186.  
  187.       n = (GLfloat) CLAMP( nearval, 0.0, 1.0 );
  188.       f = (GLfloat) CLAMP( farval, 0.0, 1.0 );
  189.  
  190.       CC.Viewport.Near = n;
  191.       CC.Viewport.Far = f;
  192.       CC.Viewport.Sz = (f - n) / 2.0;
  193.       CC.Viewport.Tz = (f - n) / 2.0 + n;
  194.    }
  195. }
  196.  
  197.  
  198.  
  199. /*
  200.  * Apply depth buffer test to a horizontal span of pixels:
  201.  *
  202.  * FOREACH pixel[i] in the span DO
  203.  *    IF mask[i]!=0 THEN
  204.  *       IF depth test passes THEN
  205.  *          update z value
  206.  *       ELSE
  207.  *          mask[i] = 0;
  208.  *       ENDIF
  209.  *    ENDIF
  210.  * ENDDO
  211.  *
  212.  * Input:  n - number of pixels in the span
  213.  *         x, y - location of leftmost pixel in span in window coords
  214.  *         z - array [n] of integer z values
  215.  * In/Out:  mask - array [n] of flags (1=draw pixel, 0=don't draw) 
  216.  * Return:  number of pixels which passed depth test
  217.  */
  218. GLuint gl_depth_test_span( GLuint n, GLuint x, GLuint y, const GLint z[],
  219.                GLubyte mask[] )
  220. {
  221.    /* Apply depth buffer test to each pixel */
  222.    GLint *zptr = CC.DepthBuffer + y * CC.BufferWidth + x;
  223.    GLubyte *m = mask;
  224.    GLuint i;
  225.    register GLuint passed = 0;
  226.  
  227.    /* switch cases ordered from most frequent to less frequent */
  228.    switch (CC.Depth.Func) {
  229.       case GL_LESS:
  230.          if (CC.Depth.Mask) {
  231.         /* Update Z buffer */
  232.         for (i=0; i<n; i++,zptr++,m++) {
  233.            if (*m) {
  234.           if (z[i] < *zptr) {
  235.              /* pass */
  236.              *zptr = z[i];
  237.              passed++;
  238.           }
  239.           else {
  240.              /* fail */
  241.              *m = 0;
  242.           }
  243.            }
  244.         }
  245.      }
  246.      else {
  247.         /* Don't update Z buffer */
  248.         for (i=0; i<n; i++,zptr++,m++) {
  249.            if (*m) {
  250.           if (z[i] < *zptr) {
  251.              /* pass */
  252.              passed++;
  253.           }
  254.           else {
  255.              *m = 0;
  256.           }
  257.            }
  258.         }
  259.      }
  260.      break;
  261.       case GL_LEQUAL:
  262.      if (CC.Depth.Mask) {
  263.         /* Update Z buffer */
  264.         for (i=0;i<n;i++,zptr++,m++) {
  265.            if (*m) {
  266.           if (z[i] <= *zptr) {
  267.              *zptr = z[i];
  268.              passed++;
  269.           }
  270.           else {
  271.              *m = 0;
  272.           }
  273.            }
  274.         }
  275.      }
  276.      else {
  277.         /* Don't update Z buffer */
  278.         for (i=0;i<n;i++,zptr++,m++) {
  279.            if (*m) {
  280.           if (z[i] <= *zptr) {
  281.              /* pass */
  282.              passed++;
  283.           }
  284.           else {
  285.              *m = 0;
  286.           }
  287.            }
  288.         }
  289.      }
  290.      break;
  291.       case GL_GEQUAL:
  292.      if (CC.Depth.Mask) {
  293.         /* Update Z buffer */
  294.         for (i=0;i<n;i++,zptr++,m++) {
  295.            if (*m) {
  296.           if (z[i] >= *zptr) {
  297.              *zptr = z[i];
  298.              passed++;
  299.           }
  300.           else {
  301.              *m = 0;
  302.           }
  303.            }
  304.         }
  305.      }
  306.      else {
  307.         /* Don't update Z buffer */
  308.         for (i=0;i<n;i++,zptr++,m++) {
  309.            if (*m) {
  310.           if (z[i] >= *zptr) {
  311.              /* pass */
  312.              passed++;
  313.           }
  314.           else {
  315.              *m = 0;
  316.           }
  317.            }
  318.         }
  319.      }
  320.      break;
  321.       case GL_GREATER:
  322.      if (CC.Depth.Mask) {
  323.         /* Update Z buffer */
  324.         for (i=0;i<n;i++,zptr++,m++) {
  325.            if (*m) {
  326.           if (z[i] > *zptr) {
  327.              *zptr = z[i];
  328.              passed++;
  329.           }
  330.           else {
  331.              *m = 0;
  332.           }
  333.            }
  334.         }
  335.      }
  336.      else {
  337.         /* Don't update Z buffer */
  338.         for (i=0;i<n;i++,zptr++,m++) {
  339.            if (*m) {
  340.           if (z[i] > *zptr) {
  341.              /* pass */
  342.              passed++;
  343.           }
  344.           else {
  345.              *m = 0;
  346.           }
  347.            }
  348.         }
  349.      }
  350.      break;
  351.       case GL_NOTEQUAL:
  352.      if (CC.Depth.Mask) {
  353.         /* Update Z buffer */
  354.         for (i=0;i<n;i++,zptr++,m++) {
  355.            if (*m) {
  356.           if (z[i] != *zptr) {
  357.              *zptr = z[i];
  358.              passed++;
  359.           }
  360.           else {
  361.              *m = 0;
  362.           }
  363.            }
  364.         }
  365.      }
  366.      else {
  367.         /* Don't update Z buffer */
  368.         for (i=0;i<n;i++,zptr++,m++) {
  369.            if (*m) {
  370.           if (z[i] != *zptr) {
  371.              /* pass */
  372.              passed++;
  373.           }
  374.           else {
  375.              *m = 0;
  376.           }
  377.            }
  378.         }
  379.      }
  380.      break;
  381.       case GL_EQUAL:
  382.      if (CC.Depth.Mask) {
  383.         /* Update Z buffer */
  384.         for (i=0;i<n;i++,zptr++,m++) {
  385.            if (*m) {
  386.           if (z[i] == *zptr) {
  387.              *zptr = z[i];
  388.              passed++;
  389.           }
  390.           else {
  391.              *m =0;
  392.           }
  393.            }
  394.         }
  395.      }
  396.      else {
  397.         /* Don't update Z buffer */
  398.         for (i=0;i<n;i++,zptr++,m++) {
  399.            if (*m) {
  400.           if (z[i] == *zptr) {
  401.              /* pass */
  402.              passed++;
  403.           }
  404.           else {
  405.              *m =0;
  406.           }
  407.            }
  408.         }
  409.      }
  410.      break;
  411.       case GL_ALWAYS:
  412.      if (CC.Depth.Mask) {
  413.         /* Update Z buffer */
  414.         for (i=0;i<n;i++,zptr++,m++) {
  415.            if (*m) {
  416.           *zptr = z[i];
  417.           passed++;
  418.            }
  419.         }
  420.      }
  421.      else {
  422.         /* Don't update Z buffer or mask */
  423.         passed = n;
  424.      }
  425.      break;
  426.       case GL_NEVER:
  427.      for (i=0;i<n;i++,m++) {
  428.         *m = 0;
  429.      }
  430.      break;
  431.    } /*switch*/
  432.  
  433.    return passed;
  434. }
  435.  
  436.  
  437.  
  438. #define OFFSET(X,Y)  ( (Y) * CC.BufferWidth + (X) )
  439.  
  440.  
  441.  
  442. /*
  443.  * Perform depth testing on an array of pixels.
  444.  */
  445. void gl_depth_test_pixels( GLuint n, const GLint x[], const GLint y[],
  446.                const GLint z[], GLubyte mask[] )
  447. {
  448.    register GLint *zptr;
  449.    register GLuint i;
  450.  
  451.    /* switch cases ordered from most frequent to less frequent */
  452.    switch (CC.Depth.Func) {
  453.       case GL_LESS:
  454.          if (CC.Depth.Mask) {
  455.         /* Update Z buffer */
  456.         for (i=0; i<n; i++) {
  457.            if (mask[i]) {
  458.           zptr = CC.DepthBuffer + OFFSET(x[i],y[i]);
  459.           if (z[i] < *zptr) {
  460.              /* pass */
  461.              *zptr = z[i];
  462.           }
  463.           else {
  464.              /* fail */
  465.              mask[i] = 0;
  466.           }
  467.            }
  468.         }
  469.      }
  470.      else {
  471.         /* Don't update Z buffer */
  472.         for (i=0; i<n; i++) {
  473.            if (mask[i]) {
  474.           zptr = CC.DepthBuffer + OFFSET(x[i],y[i]);
  475.           if (z[i] < *zptr) {
  476.              /* pass */
  477.           }
  478.           else {
  479.              /* fail */
  480.              mask[i] = 0;
  481.           }
  482.            }
  483.         }
  484.      }
  485.      break;
  486.       case GL_LEQUAL:
  487.          if (CC.Depth.Mask) {
  488.         /* Update Z buffer */
  489.         for (i=0; i<n; i++) {
  490.            if (mask[i]) {
  491.           zptr = CC.DepthBuffer + OFFSET(x[i],y[i]);
  492.           if (z[i] <= *zptr) {
  493.              /* pass */
  494.              *zptr = z[i];
  495.           }
  496.           else {
  497.              /* fail */
  498.              mask[i] = 0;
  499.           }
  500.            }
  501.         }
  502.      }
  503.      else {
  504.         /* Don't update Z buffer */
  505.         for (i=0; i<n; i++) {
  506.            if (mask[i]) {
  507.           zptr = CC.DepthBuffer + OFFSET(x[i],y[i]);
  508.           if (z[i] <= *zptr) {
  509.              /* pass */
  510.           }
  511.           else {
  512.              /* fail */
  513.              mask[i] = 0;
  514.           }
  515.            }
  516.         }
  517.      }
  518.      break;
  519.       case GL_GEQUAL:
  520.          if (CC.Depth.Mask) {
  521.         /* Update Z buffer */
  522.         for (i=0; i<n; i++) {
  523.            if (mask[i]) {
  524.           zptr = CC.DepthBuffer + OFFSET(x[i],y[i]);
  525.           if (z[i] >= *zptr) {
  526.              /* pass */
  527.              *zptr = z[i];
  528.           }
  529.           else {
  530.              /* fail */
  531.              mask[i] = 0;
  532.           }
  533.            }
  534.         }
  535.      }
  536.      else {
  537.         /* Don't update Z buffer */
  538.         for (i=0; i<n; i++) {
  539.            if (mask[i]) {
  540.           zptr = CC.DepthBuffer + OFFSET(x[i],y[i]);
  541.           if (z[i] >= *zptr) {
  542.              /* pass */
  543.           }
  544.           else {
  545.              /* fail */
  546.              mask[i] = 0;
  547.           }
  548.            }
  549.         }
  550.      }
  551.      break;
  552.       case GL_GREATER:
  553.          if (CC.Depth.Mask) {
  554.         /* Update Z buffer */
  555.         for (i=0; i<n; i++) {
  556.            if (mask[i]) {
  557.           zptr = CC.DepthBuffer + OFFSET(x[i],y[i]);
  558.           if (z[i] > *zptr) {
  559.              /* pass */
  560.              *zptr = z[i];
  561.           }
  562.           else {
  563.              /* fail */
  564.              mask[i] = 0;
  565.           }
  566.            }
  567.         }
  568.      }
  569.      else {
  570.         /* Don't update Z buffer */
  571.         for (i=0; i<n; i++) {
  572.            if (mask[i]) {
  573.           zptr = CC.DepthBuffer + OFFSET(x[i],y[i]);
  574.           if (z[i] > *zptr) {
  575.              /* pass */
  576.           }
  577.           else {
  578.              /* fail */
  579.              mask[i] = 0;
  580.           }
  581.            }
  582.         }
  583.      }
  584.      break;
  585.       case GL_NOTEQUAL:
  586.          if (CC.Depth.Mask) {
  587.         /* Update Z buffer */
  588.         for (i=0; i<n; i++) {
  589.            if (mask[i]) {
  590.           zptr = CC.DepthBuffer + OFFSET(x[i],y[i]);
  591.           if (z[i] != *zptr) {
  592.              /* pass */
  593.              *zptr = z[i];
  594.           }
  595.           else {
  596.              /* fail */
  597.              mask[i] = 0;
  598.           }
  599.            }
  600.         }
  601.      }
  602.      else {
  603.         /* Don't update Z buffer */
  604.         for (i=0; i<n; i++) {
  605.            if (mask[i]) {
  606.           zptr = CC.DepthBuffer + OFFSET(x[i],y[i]);
  607.           if (z[i] != *zptr) {
  608.              /* pass */
  609.           }
  610.           else {
  611.              /* fail */
  612.              mask[i] = 0;
  613.           }
  614.            }
  615.         }
  616.      }
  617.      break;
  618.       case GL_EQUAL:
  619.          if (CC.Depth.Mask) {
  620.         /* Update Z buffer */
  621.         for (i=0; i<n; i++) {
  622.            if (mask[i]) {
  623.           zptr = CC.DepthBuffer + OFFSET(x[i],y[i]);
  624.           if (z[i] == *zptr) {
  625.              /* pass */
  626.              *zptr = z[i];
  627.           }
  628.           else {
  629.              /* fail */
  630.              mask[i] = 0;
  631.           }
  632.            }
  633.         }
  634.      }
  635.      else {
  636.         /* Don't update Z buffer */
  637.         for (i=0; i<n; i++) {
  638.            if (mask[i]) {
  639.           zptr = CC.DepthBuffer + OFFSET(x[i],y[i]);
  640.           if (z[i] == *zptr) {
  641.              /* pass */
  642.           }
  643.           else {
  644.              /* fail */
  645.              mask[i] = 0;
  646.           }
  647.            }
  648.         }
  649.      }
  650.      break;
  651.       case GL_ALWAYS:
  652.      if (CC.Depth.Mask) {
  653.         /* Update Z buffer */
  654.         for (i=0; i<n; i++) {
  655.            if (mask[i]) {
  656.           zptr = CC.DepthBuffer + OFFSET(x[i],y[i]);
  657.           *zptr = z[i];
  658.            }
  659.         }
  660.      }
  661.      else {
  662.         /* Don't update Z buffer or mask */
  663.      }
  664.      break;
  665.       case GL_NEVER:
  666.      /* depth test never passes */
  667.      for (i=0;i<n;i++) {
  668.         mask[i] = 0;
  669.      }
  670.      break;
  671.    } /*switch*/
  672. }
  673.  
  674.  
  675.  
  676.  
  677. /*
  678.  * Return a span of depth values from the depth buffer as floats in [0,1].
  679.  * Input:  n - how many pixels
  680.  *         x,y - location of first pixel
  681.  * Output:  depth - the array of depth values
  682.  */
  683. void gl_read_depth_span( GLuint n, GLint x, GLint y, GLfloat depth[] )
  684. {
  685.    GLint *d;
  686.    GLfloat scale;
  687.    GLuint i;
  688.  
  689.    scale = 1.0 / (GLfloat) MAX_DEPTH;
  690.  
  691.    if (CC.DepthBuffer) {
  692.       d = CC.DepthBuffer + y * CC.BufferWidth + x;
  693.       for (i=0;i<n;i++) {
  694.      depth[i] = (GLfloat) d[i] * scale;
  695.       }
  696.    }
  697.    else {
  698.       for (i=0;i<n;i++) {
  699.      depth[i] = 0.0F;
  700.       }
  701.    }
  702. }
  703.  
  704.  
  705.  
  706. void gl_alloc_depth_buffer( void )
  707. {
  708.    /* deallocate current depth buffer if present */
  709.    if (CC.DepthBuffer) {
  710.       free(CC.DepthBuffer);
  711.       CC.DepthBuffer = NULL;
  712.    }
  713.  
  714.    /* allocate new depth buffer */
  715.    CC.DepthBuffer = (GLint *)
  716.         malloc( CC.BufferWidth * CC.BufferHeight * sizeof(GLint) );
  717.    if (!CC.DepthBuffer) {
  718.       /* out of memory */
  719.       CC.Depth.Test = GL_FALSE;
  720.       gl_error( GL_OUT_OF_MEMORY, "Couldn't allocate depth buffer" );
  721.    }
  722. }
  723.  
  724.  
  725.  
  726.  
  727. /*
  728.  * Clear the depth buffer.  If the depth buffer doesn't exist yet we'll
  729.  * allocate it now.
  730.  */
  731. void gl_clear_depth_buffer( void )
  732. {
  733.    /* The loops in this function have been written so the IRIX 5.3
  734.     * C compiler can unroll them.  Hopefully other compilers can too!
  735.     */
  736.  
  737.    if (!CC.DepthBuffer) {
  738.       gl_alloc_depth_buffer();
  739.    }
  740.  
  741.    if (CC.DepthBuffer) {
  742.       GLint clear_value = (GLint) (CC.Depth.Clear * MAX_DEPTH);
  743.  
  744.       if (CC.Scissor.Enabled) {
  745.      /* only clear scissor region */
  746.      GLint y;
  747.      for (y=CC.Scissor.Ymin; y<=CC.Scissor.Ymax; y++) {
  748.             GLint *b = CC.DepthBuffer + y * CC.BufferWidth + CC.Scissor.Xmin;
  749.             GLint n = CC.Scissor.Xmax - CC.Scissor.Xmin + 1;
  750.             do {
  751.                *b++ = clear_value;
  752.                n--;
  753.             } while (n);
  754.      }
  755.       }
  756.       else {
  757.      /* clear whole buffer */
  758.      GLint *b = CC.DepthBuffer;
  759.      GLint n = CC.BufferWidth * CC.BufferHeight;
  760.          while (n>=16) {
  761.             b[0] = clear_value;    b[1] = clear_value;
  762.             b[2] = clear_value;    b[3] = clear_value;
  763.             b[4] = clear_value;    b[5] = clear_value;
  764.             b[6] = clear_value;    b[7] = clear_value;
  765.             b[8] = clear_value;    b[9] = clear_value;
  766.             b[10] = clear_value;   b[11] = clear_value;
  767.             b[12] = clear_value;   b[13] = clear_value;
  768.             b[14] = clear_value;   b[15] = clear_value;
  769.             b += 16;
  770.             n -= 16;
  771.          }
  772.          while (n>0) {
  773.             *b++ = clear_value;
  774.             n--;
  775.          }
  776.       }
  777.    }
  778. }
  779.  
  780.  
  781.  
  782.